﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace AdbRegisterUtils
{

    /// <summary>
    /// Logcat数据管理器
    /// </summary>
    public static class LogcatDataManager
    {
        private static List<LogcatModel> _logcatModels = new List<LogcatModel>();
        private static readonly object _lockObject = new object();

        // 全局变量：控制最大存储数量
        private static int _maxLogCount = 2000;

        /// <summary>
        /// 设置或获取最大日志记录数量
        /// </summary>
        public static int MaxLogCount
        {
            get { return _maxLogCount; }
            set
            {
                if (value > 0)
                {
                    _maxLogCount = value;
                    Console.WriteLine($"[LogcatDataManager] 最大日志数量设置为: {_maxLogCount}");

                    // 如果当前数据量超过新设置的最大值，则进行清理
                    TrimExcessData();
                }
                else
                {
                    Console.WriteLine($"[LogcatDataManager WARNING] 无效的最大日志数量: {value}，必须大于0");
                }
            }
        }

        /// <summary>
        /// 从日志行中解析寄存器信息并自动存储
        /// </summary>
        /// <param name="logLine">日志行</param>
        /// <returns>解析是否成功</returns>
        public static bool ParseAndStoreRegisterLog(string logLine)
        {
            if (string.IsNullOrEmpty(logLine))
                return false;

            // 优化后的正则表达式，更精确地匹配日志格式
            Match match = Regex.Match(
                logLine,
                @"(ISP|Sensor|Reg)(Read|Write)\s+.*?addr=(0x[0-9a-fA-F]+)\s+val=(0x[0-9a-fA-F]+)\s+id=([0-9]+)\s+online=([0-9]+)");

            if (!match.Success)
                return false;

            try
            {
                string module = match.Groups[1].Value;
                string operation = match.Groups[2].Value;
                string regAddr = match.Groups[3].Value;
                string value = match.Groups[4].Value;
                string id = match.Groups[5].Value;
                bool isRead = string.Equals(operation, "read", StringComparison.OrdinalIgnoreCase);
                bool online = match.Groups[6].Value == "1";

                // 创建LogcatModel对象
                var logcatModel = new LogcatModel
                {
                    Date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"),
                    Operation = isRead ? "Read" : "Write",
                    RWText = module,
                    RegAddr = regAddr,
                    Values = value,
                    Online = online
                };

                // 存储到数据管理器
                AddData(logcatModel);

                Console.WriteLine($"[LogcatDataManager] 成功解析并存储日志: {module}{operation}, 地址: {regAddr}, 值: {value}, 在线: {online}");
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[LogcatDataManager ERROR] 解析日志失败: {ex.Message}, 日志行: {logLine}");
                return false;
            }
        }

        /// <summary>
        /// 获取所有Logcat数据
        /// </summary>
        public static List<LogcatModel> GetAllData()
        {
            lock (_lockObject)
            {
                return new List<LogcatModel>(_logcatModels);
            }
        }
        /// <summary>
        /// 添加单个Logcat数据
        /// </summary>
        /// <param name="model">Logcat数据模型</param>
        public static void AddData(LogcatModel model)
        {
            if (model == null)
                return;

            lock (_lockObject)
            {
                _logcatModels.Add(model);

                // 检查数据量是否超过最大值，如果超过则移除最早的数据
                if (_logcatModels.Count > _maxLogCount)
                {
                    int removeCount = _logcatModels.Count - _maxLogCount;
                    _logcatModels.RemoveRange(0, removeCount);
                    //Console.WriteLine($"[LogcatDataManager] 已移除 {removeCount} 条最早的数据，保持最大数量: {_maxLogCount}");
                }

                //Console.WriteLine($"[LogcatDataManager] 已添加数据，寄存器: {model.RegAddr}，操作: {model.Operation}，当前总数: {_logcatModels.Count}");
            }
        }
        
        /// 根据寄存器地址查找数据，如果未找到则返回默认值"0"
        /// </summary>
        /// <param name="regAddr">寄存器地址</param>
        /// <param name="timeoutMs">超时时间（毫秒），默认为0表示不等待</param>
        /// <returns>匹配的数据或默认值"0"</returns>
        public static async Task<LogcatModel> FindByRegisterAddress(string regAddr, int timeoutMs = 0)
        {
            if (string.IsNullOrWhiteSpace(regAddr))
            {
                Console.WriteLine($"[LogcatDataManager] 寄存器地址为空，返回默认值0");
                return new LogcatModel();
            }

            try
            {
                var startTime = DateTime.Now;
                bool valueFound = false;
                LogcatModel result = null;

                // 如果有超时设置，使用循环等待
                while (timeoutMs <= 0 || (DateTime.Now - startTime).TotalMilliseconds < timeoutMs)
                {
                    // 在锁内执行查找操作
                    lock (_lockObject)
                    {
                        // 统一格式化寄存器地址
                        string formattedAddr = regAddr.Trim();
                        if (!formattedAddr.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
                        {
                            formattedAddr = "0x" + formattedAddr;
                        }
                        formattedAddr = formattedAddr.ToLowerInvariant();

                        // 查找最后一个匹配的记录
                        result = _logcatModels.FindLast(m =>
                            !string.IsNullOrWhiteSpace(m.RegAddr) &&
                            m.RegAddr.Trim().ToLowerInvariant().Equals(formattedAddr));

                        if (result != null && !string.IsNullOrEmpty(result.Values))
                        {
                            Console.WriteLine($"[LogcatDataManager] 根据寄存器地址 '{regAddr}' 找到记录，值: {result.Values}");
                            valueFound = true;
                            break;
                        }
                    }

                    // 如果找到了或者不需要等待，直接退出
                    if (valueFound || timeoutMs <= 0)
                        break;

                    // 异步等待一段时间再重试
                    await Task.Delay(50);
                }

                if (valueFound)
                {
                    return result;
                }
                else
                {
                    Console.WriteLine($"[LogcatDataManager] 根据寄存器地址 '{regAddr}' 未找到匹配记录，返回默认值0");
                    return new LogcatModel();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[LogcatDataManager ERROR] 查找寄存器地址 '{regAddr}' 时发生异常: {ex.Message}");
                return new LogcatModel();
            }
        }
        
        
        
        /// <summary>
        /// 清理超出最大限制的数据
        /// </summary>
        private static void TrimExcessData()
        {
            lock (_lockObject)
            {
                if (_logcatModels.Count > _maxLogCount)
                {
                    int removeCount = _logcatModels.Count - _maxLogCount;
                    _logcatModels.RemoveRange(0, removeCount);
                    Console.WriteLine($"[LogcatDataManager] 已清理 {removeCount} 条数据，当前总数: {_logcatModels.Count}");
                }
            }
        }


    }


}
